home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / cool / cool.lha / ice / pisces / flex / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-04  |  16.5 KB  |  677 lines
  1. /* flex - tool to generate fast lexical analyzers
  2.  *
  3.  *
  4.  * Copyright (c) 1989 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant to
  11.  * contract no. DE-AC03-76SF00098 between the United States Department of
  12.  * Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted
  15.  * provided that the above copyright notice and this paragraph are
  16.  * duplicated in all such forms and that any documentation,
  17.  * advertising materials, and other materials related to such
  18.  * distribution and use acknowledge that the software was developed
  19.  * by the University of California, Berkeley.  The name of the
  20.  * University may not be used to endorse or promote products derived
  21.  * from this software without specific prior written permission.
  22.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  23.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  24.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  25.  *
  26.  */
  27.  
  28. #ifndef lint
  29.  
  30. static char copyright[] =
  31.     "@(#) Copyright (c) 1989 The Regents of the University of California.\n";
  32. static char CR_continuation[] = "@(#) All rights reserved.\n";
  33.  
  34. static char rcsid[] =
  35.     "@(#) $Header: /tan/u1/neath/pisces/flex/RCS/main.c,v 1.1 90/05/15 13:13:43 neath Exp $ (LBL)";
  36.  
  37. #endif
  38.  
  39.  
  40. #include "flexdef.h"
  41.  
  42. static char flex_version[] = "2.1.cxx (beta)";
  43.  
  44.  
  45. /* these globals are all defined and commented in flexdef.h */
  46. int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt;
  47. int interactive, caseins, useecs, fulltbl, usemecs;
  48. int fullspd, gen_line_dirs, performance_report, backtrack_report;
  49. int cplusplus;
  50. int yymore_used, reject, real_reject, continued_action;
  51. int yymore_really_used, reject_really_used;
  52. int datapos, dataline, linenum;
  53. FILE *skelfile = NULL;
  54. char *infilename = NULL;
  55. int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  56. int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  57. int current_mns, num_rules, current_max_rules, lastnfa;
  58. int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  59. int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum;
  60. int current_state_type;
  61. int variable_trailing_context_rules;
  62. int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  63. int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  64. int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
  65. int tecbck[CSIZE + 1];
  66. int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
  67. char **scname;
  68. int current_max_dfa_size, current_max_xpairs;
  69. int current_max_template_xpairs, current_max_dfas;
  70. int lastdfa, *nxt, *chk, *tnxt;
  71. int *base, *def, tblend, firstfree, **dss, *dfasiz;
  72. union dfaacc_union *dfaacc;
  73. int *accsiz, *dhash, numas;
  74. int numsnpairs, jambase, jamstate;
  75. int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
  76. int current_max_ccl_tbl_size;
  77. char *ccltbl;
  78. char *starttime, *endtime, nmstr[MAXLINE];
  79. int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  80. int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
  81. int num_backtracking, bol_needed;
  82. FILE *temp_action_file;
  83. FILE *backtrack_file;
  84. int end_of_buffer_state;
  85. #ifndef SHORT_FILE_NAMES
  86. char action_file_name[] = "/tmp/flexXXXX";
  87. #else
  88. char action_file_name[] = "flexXXXX.tmp";
  89. #endif
  90.  
  91. #ifndef SHORT_FILE_NAMES
  92. static char outfile[] = "lex.yy.c";
  93. #else
  94. static char outfile[] = "lex_yy.c";
  95. #endif
  96. static int outfile_created = 0;
  97.  
  98.  
  99. /* flex - main program
  100.  *
  101.  * synopsis (from the shell)
  102.  *    flex [-v] [file ...]
  103.  */
  104.  
  105. main( argc, argv )
  106. int argc;
  107. char **argv;
  108.  
  109.     {
  110.     flexinit( argc, argv );
  111.  
  112.     readin();
  113.  
  114.     if ( syntaxerror )
  115.     flexend( 1 );
  116.  
  117.     if ( yymore_really_used == REALLY_USED )
  118.     yymore_used = true;
  119.     else if ( yymore_really_used == REALLY_NOT_USED )
  120.     yymore_used = false;
  121.  
  122.     if ( reject_really_used == REALLY_USED )
  123.     reject = true;
  124.     else if ( reject_really_used == REALLY_NOT_USED )
  125.     reject = false;
  126.  
  127.     if ( performance_report )
  128.     {
  129.     if ( yymore_used )
  130.         fprintf( stderr,
  131.              "yymore() entails a minor performance penalty\n" );
  132.  
  133.     if ( interactive )
  134.         fprintf( stderr,
  135.          "-I (interactive) entails a minor performance penalty\n" );
  136.  
  137.     if ( reject )
  138.         fprintf( stderr,
  139.              "REJECT entails a large performance penalty\n" );
  140.  
  141.     if ( variable_trailing_context_rules )
  142.         fprintf( stderr,
  143. "Variable trailing context rules entail a large performance penalty\n" );
  144.     }
  145.  
  146.     if ( reject )
  147.     real_reject = true;
  148.  
  149.     if ( variable_trailing_context_rules )
  150.     reject = true;
  151.  
  152.     if ( (fulltbl || fullspd) && reject )
  153.     {
  154.     if ( real_reject )
  155.         flexerror( "REJECT cannot be used with -f or -F" );
  156.     else
  157.         flexerror(
  158.     "variable trailing context rules cannot be used with -f or -F" );
  159.     }
  160.  
  161.     /* convert the ndfa to a dfa */
  162.     ntod();
  163.  
  164.     /* generate the C state transition tables from the DFA */
  165.     make_tables();
  166.  
  167.     /* note, flexend does not return.  It exits with its argument as status. */
  168.  
  169.     flexend( 0 );
  170.  
  171.     /*NOTREACHED*/
  172.     }
  173.  
  174.  
  175. /* flexend - terminate flex
  176.  *
  177.  * synopsis
  178.  *    int status;
  179.  *    flexend( status );
  180.  *
  181.  *    status is exit status.
  182.  *
  183.  * note
  184.  *    This routine does not return.
  185.  */
  186.  
  187. flexend( status )
  188. int status;
  189.  
  190.     {
  191.     int tblsiz;
  192.     char *flex_gettime();
  193.  
  194.     if ( skelfile != NULL )
  195.     (void) fclose( skelfile );
  196.  
  197.     if ( temp_action_file )
  198.     {
  199.     (void) fclose( temp_action_file );
  200.     (void) unlink( action_file_name );
  201.     }
  202.  
  203.     if ( status != 0 && outfile_created )
  204.     {
  205.     (void) fclose( stdout );
  206.     (void) unlink( outfile );
  207.     }
  208.  
  209.     if ( backtrack_report )
  210.     {
  211.     if ( num_backtracking == 0 )
  212.         fprintf( backtrack_file, "No backtracking.\n" );
  213.     else if ( fullspd || fulltbl )
  214.         fprintf( backtrack_file,
  215.              "%d backtracking (non-accepting) states.\n",
  216.              num_backtracking );
  217.     else
  218.         fprintf( backtrack_file, "Compressed tables always backtrack.\n" );
  219.  
  220.     (void) fclose( backtrack_file );
  221.     }
  222.  
  223.     if ( printstats )
  224.     {
  225.     endtime = flex_gettime();
  226.  
  227.     fprintf( stderr, "flex version %s usage statistics:\n", flex_version );
  228.     fprintf( stderr, "  started at %s, finished at %s\n",
  229.          starttime, endtime );
  230.  
  231.     fprintf( stderr, "  %d/%d NFA states\n", lastnfa, current_mns );
  232.     fprintf( stderr, "  %d/%d DFA states (%d words)\n", lastdfa,
  233.              current_max_dfas, totnst );
  234.     fprintf( stderr, "  %d rules\n", num_rules - 1 /* - 1 for def. rule */ );
  235.  
  236.     if ( num_backtracking == 0 )
  237.         fprintf( stderr, "  No backtracking\n" );
  238.     else if ( fullspd || fulltbl )
  239.         fprintf( stderr, "  %d backtracking (non-accepting) states\n",
  240.              num_backtracking );
  241.     else
  242.         fprintf( stderr, "  compressed tables always backtrack\n" );
  243.  
  244.     if ( bol_needed )
  245.         fprintf( stderr, "  Beginning-of-line patterns used\n" );
  246.  
  247.     fprintf( stderr, "  %d/%d start conditions\n", lastsc,
  248.              current_max_scs );
  249.     fprintf( stderr, "  %d epsilon states, %d double epsilon states\n",
  250.          numeps, eps2 );
  251.  
  252.     if ( lastccl == 0 )
  253.         fprintf( stderr, "  no character classes\n" );
  254.     else
  255.         fprintf( stderr,
  256.     "  %d/%d character classes needed %d/%d words of storage, %d reused\n",
  257.              lastccl, current_maxccls,
  258.              cclmap[lastccl] + ccllen[lastccl],
  259.              current_max_ccl_tbl_size, cclreuse );
  260.  
  261.     fprintf( stderr, "  %d state/nextstate pairs created\n", numsnpairs );
  262.     fprintf( stderr, "  %d/%d unique/duplicate transitions\n",
  263.          numuniq, numdup );
  264.  
  265.     if ( fulltbl )
  266.         {
  267.         tblsiz = lastdfa * numecs;
  268.         fprintf( stderr, "  %d table entries\n", tblsiz );
  269.         }
  270.  
  271.     else
  272.         {
  273.         tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
  274.  
  275.         fprintf( stderr, "  %d/%d base-def entries created\n",
  276.              lastdfa + numtemps, current_max_dfas );
  277.         fprintf( stderr, "  %d/%d (peak %d) nxt-chk entries created\n",
  278.              tblend, current_max_xpairs, peakpairs );
  279.         fprintf( stderr,
  280.              "  %d/%d (peak %d) template nxt-chk entries created\n",
  281.              numtemps * nummecs, current_max_template_xpairs,
  282.              numtemps * numecs );
  283.         fprintf( stderr, "  %d empty table entries\n", nummt );
  284.         fprintf( stderr, "  %d protos created\n", numprots );
  285.         fprintf( stderr, "  %d templates created, %d uses\n",
  286.              numtemps, tmpuses );
  287.         }
  288.  
  289.     if ( useecs )
  290.         {
  291.         tblsiz = tblsiz + CSIZE;
  292.         fprintf( stderr, "  %d/%d equivalence classes created\n",
  293.              numecs, CSIZE );
  294.         }
  295.  
  296.     if ( usemecs )
  297.         {
  298.         tblsiz = tblsiz + numecs;
  299.         fprintf( stderr, "  %d/%d meta-equivalence classes created\n",
  300.              nummecs, CSIZE );
  301.         }
  302.  
  303.     fprintf( stderr, "  %d (%d saved) hash collisions, %d DFAs equal\n",
  304.          hshcol, hshsave, dfaeql );
  305.     fprintf( stderr, "  %d sets of reallocations needed\n", num_reallocs );
  306.     fprintf( stderr, "  %d total table entries needed\n", tblsiz );
  307.     }
  308.  
  309. #ifndef VMS
  310.     exit( status );
  311. #else
  312.     exit( status + 1 );
  313. #endif
  314.     }
  315.  
  316.  
  317. /* flexinit - initialize flex
  318.  *
  319.  * synopsis
  320.  *    int argc;
  321.  *    char **argv;
  322.  *    flexinit( argc, argv );
  323.  */
  324.  
  325. flexinit( argc, argv )
  326. int argc;
  327. char **argv;
  328.  
  329.     {
  330.     int i, sawcmpflag, use_stdout;
  331.     char *arg, *skelname = NULL, *flex_gettime(), clower(), *mktemp();
  332.  
  333.     printstats = syntaxerror = trace = spprdflt = interactive = caseins = false;
  334.     backtrack_report = performance_report = ddebug = fulltbl = fullspd = false;
  335.     yymore_used = cplusplus = continued_action = reject = false;
  336.     yymore_really_used = reject_really_used = false;
  337.     gen_line_dirs = usemecs = useecs = true;
  338.  
  339.     sawcmpflag = false;
  340.     use_stdout = false;
  341.  
  342.     /* read flags */
  343.     for ( --argc, ++argv; argc ; --argc, ++argv )
  344.     {
  345.     if ( argv[0][0] != '-' || argv[0][1] == '\0' )
  346.         break;
  347.  
  348.     arg = argv[0];
  349.  
  350.     for ( i = 1; arg[i] != '\0'; ++i )
  351.         switch ( arg[i] )
  352.         {
  353.         case 'C':
  354.             cplusplus = true;
  355.             break;
  356.  
  357.         case 'b':
  358.             backtrack_report = true;
  359.             break;
  360.  
  361.         case 'c':
  362.             if ( i != 1 )
  363.             flexerror( "-c flag must be given separately" );
  364.  
  365.             if ( ! sawcmpflag )
  366.             {
  367.             useecs = false;
  368.             usemecs = false;
  369.             fulltbl = false;
  370.             sawcmpflag = true;
  371.             }
  372.  
  373.             for ( ++i; arg[i] != '\0'; ++i )
  374.             switch ( clower( arg[i] ) )
  375.                 {
  376.                 case 'e':
  377.                 useecs = true;
  378.                 break;
  379.  
  380.                 case 'F':
  381.                 fullspd = true;
  382.                 break;
  383.  
  384.                 case 'f':
  385.                 fulltbl = true;
  386.                 break;
  387.  
  388.                 case 'm':
  389.                 usemecs = true;
  390.                 break;
  391.  
  392.                 default:
  393.                 lerrif( "unknown -c option %c",
  394.                     (int) arg[i] );
  395.                 break;
  396.                 }
  397.             
  398.             goto get_next_arg;
  399.  
  400.         case 'd':
  401.             ddebug = true;
  402.             break;
  403.  
  404.         case 'f':
  405.             useecs = usemecs = false;
  406.             fulltbl = true;
  407.             break;
  408.  
  409.         case 'F':
  410.             useecs = usemecs = false;
  411.             fullspd = true;
  412.             break;
  413.  
  414.         case 'I':
  415.             interactive = true;
  416.             break;
  417.  
  418.         case 'i':
  419.             caseins = true;
  420.             break;
  421.  
  422.         case 'L':
  423.             gen_line_dirs = false;
  424.             break;
  425.  
  426.         case 'p':
  427.             performance_report = true;
  428.             break;
  429.  
  430.         case 'S':
  431.             if ( i != 1 )
  432.             flexerror( "-S flag must be given separately" );
  433.  
  434.             skelname = arg + i + 1;
  435.             goto get_next_arg;
  436.  
  437.         case 's':
  438.             spprdflt = true;
  439.             break;
  440.  
  441.         case 't':
  442.             use_stdout = true;
  443.             break;
  444.  
  445.         case 'T':
  446.             trace = true;
  447.             break;
  448.  
  449.         case 'v':
  450.             printstats = true;
  451.             break;
  452.  
  453.         default:
  454.             lerrif( "unknown flag %c", (int) arg[i] );
  455.             break;
  456.         }
  457.  
  458. get_next_arg: /* used by -c and -S flags in lieu of a "continue 2" control */
  459.     ;
  460.     }
  461.  
  462.     if ( (fulltbl || fullspd) && usemecs )
  463.     flexerror( "full table and -cm don't make sense together" );
  464.  
  465.     if ( (fulltbl || fullspd) && interactive )
  466.     flexerror( "full table and -I are (currently) incompatible" );
  467.  
  468.     if ( fulltbl && fullspd )
  469.     flexerror( "full table and -F are mutually exclusive" );
  470.  
  471.     if ( ! skelname )
  472.     {
  473.     static char skeleton_name_storage[400];
  474.  
  475.     skelname = skeleton_name_storage;
  476.     (void) strcpy( skelname, SKELFILE );
  477.     }
  478.  
  479.     if ( ! use_stdout )
  480.     {
  481.     FILE *prev_stdout = freopen( outfile, "w", stdout );
  482.  
  483.     if ( prev_stdout == NULL )
  484.         flexerror( "could not create lex.yy.c" );
  485.  
  486.     outfile_created = 1;
  487.     }
  488.  
  489.     if ( argc )
  490.     {
  491.     if ( argc > 1 )
  492.         flexerror( "extraneous argument(s) given" );
  493.  
  494.     yyin = fopen( infilename = argv[0], "r" );
  495.  
  496.     if ( yyin == NULL )
  497.         lerrsf( "can't open %s", argv[0] );
  498.     }
  499.  
  500.     else
  501.     yyin = stdin;
  502.  
  503.     if ( backtrack_report )
  504.     {
  505. #ifndef SHORT_FILE_NAMES
  506.     backtrack_file = fopen( "lex.backtrack", "w" );
  507. #else
  508.     backtrack_file = fopen( "lex.bck", "w" );
  509. #endif
  510.  
  511.     if ( backtrack_file == NULL )
  512.         flexerror( "could not create lex.backtrack" );
  513.     }
  514.  
  515.     else
  516.     backtrack_file = NULL;
  517.  
  518.  
  519.     lastccl = 0;
  520.     lastsc = 0;
  521.  
  522.     /* initialize the statistics */
  523.     starttime = flex_gettime();
  524.  
  525.     if ( (skelfile = fopen( skelname, "r" )) == NULL )
  526.     lerrsf( "can't open skeleton file %s", skelname );
  527.  
  528.     (void) mktemp( action_file_name );
  529.  
  530.     if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL )
  531.     lerrsf( "can't open temporary action file %s", action_file_name );
  532.  
  533.     lastdfa = lastnfa = num_rules = numas = numsnpairs = tmpuses = 0;
  534.     numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
  535.     numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
  536.     num_backtracking = onesp = numprots = 0;
  537.     variable_trailing_context_rules = bol_needed = false;
  538.  
  539.     linenum = sectnum = 1;
  540.     firstprot = NIL;
  541.  
  542.     /* used in mkprot() so that the first proto goes in slot 1
  543.      * of the proto queue
  544.      */
  545.     lastprot = 1;
  546.  
  547.     if ( useecs )
  548.     {
  549.     /* set up doubly-linked equivalence classes */
  550.     ecgroup[1] = NIL;
  551.  
  552.     for ( i = 2; i <= CSIZE; ++i )
  553.         {
  554.         ecgroup[i] = i - 1;
  555.         nextecm[i - 1] = i;
  556.         }
  557.  
  558.     nextecm[CSIZE] = NIL;
  559.     }
  560.  
  561.     else
  562.     { /* put everything in its own equivalence class */
  563.     for ( i = 1; i <= CSIZE; ++i )
  564.         {
  565.         ecgroup[i] = i;
  566.         nextecm[i] = BAD_SUBSCRIPT;    /* to catch errors */
  567.         }
  568.     }
  569.  
  570.     set_up_initial_allocations();
  571.     }
  572.  
  573.  
  574. /* readin - read in the rules section of the input file(s)
  575.  *
  576.  * synopsis
  577.  *    readin();
  578.  */
  579.  
  580. readin()
  581.     {
  582.     if ( cplusplus )
  583.     {
  584.     puts("#ifndef __cplusplus");    /* better safe, than ... */
  585.     puts("#  define __cplusplus");
  586.     puts("#endif\n");
  587.     puts("extern \"C\"");
  588.     puts("{\n  void exit(int);");
  589.     puts("  int read(int, char *, int);\n}");
  590.     }
  591.     if ( ddebug )
  592.     puts( "#define FLEX_DEBUG" );
  593.  
  594.     if ( fulltbl )
  595.     puts( "#define FLEX_FULL_TABLE" );
  596.     else if ( fullspd )
  597.     puts( "#define FLEX_FAST_COMPRESSED" );
  598.     else
  599.     puts( "#define FLEX_COMPRESSED" );
  600.  
  601.     skelout();
  602.  
  603.     line_directive_out( stdout );
  604.  
  605.     if ( yyparse() )
  606.     lerrif( "fatal parse error at line %d", linenum );
  607.  
  608.     if ( useecs )
  609.     {
  610.     numecs = cre8ecs( nextecm, ecgroup, CSIZE );
  611.     ccl2ecl();
  612.     }
  613.  
  614.     else
  615.     numecs = CSIZE;
  616.  
  617.     }
  618.  
  619.  
  620.  
  621. /* set_up_initial_allocations - allocate memory for internal tables */
  622.  
  623. set_up_initial_allocations()
  624.  
  625.     {
  626.     current_mns = INITIAL_MNS;
  627.     firstst = allocate_integer_array( current_mns );
  628.     lastst = allocate_integer_array( current_mns );
  629.     finalst = allocate_integer_array( current_mns );
  630.     transchar = allocate_integer_array( current_mns );
  631.     trans1 = allocate_integer_array( current_mns );
  632.     trans2 = allocate_integer_array( current_mns );
  633.     accptnum = allocate_integer_array( current_mns );
  634.     assoc_rule = allocate_integer_array( current_mns );
  635.     state_type = allocate_integer_array( current_mns );
  636.  
  637.     current_max_rules = INITIAL_MAX_RULES;
  638.     rule_type = allocate_integer_array( current_max_rules );
  639.     rule_linenum = allocate_integer_array( current_max_rules );
  640.  
  641.     current_max_scs = INITIAL_MAX_SCS;
  642.     scset = allocate_integer_array( current_max_scs );
  643.     scbol = allocate_integer_array( current_max_scs );
  644.     scxclu = allocate_integer_array( current_max_scs );
  645.     sceof = allocate_integer_array( current_max_scs );
  646.     scname = allocate_char_ptr_array( current_max_scs );
  647.     actvsc = allocate_integer_array( current_max_scs );
  648.  
  649.     current_maxccls = INITIAL_MAX_CCLS;
  650.     cclmap = allocate_integer_array( current_maxccls );
  651.     ccllen = allocate_integer_array( current_maxccls );
  652.     cclng = allocate_integer_array( current_maxccls );
  653.  
  654.     current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
  655.     ccltbl = allocate_character_array( current_max_ccl_tbl_size );
  656.  
  657.     current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
  658.  
  659.     current_max_xpairs = INITIAL_MAX_XPAIRS;
  660.     nxt = allocate_integer_array( current_max_xpairs );
  661.     chk = allocate_integer_array( current_max_xpairs );
  662.  
  663.     current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
  664.     tnxt = allocate_integer_array( current_max_template_xpairs );
  665.  
  666.     current_max_dfas = INITIAL_MAX_DFAS;
  667.     base = allocate_integer_array( current_max_dfas );
  668.     def = allocate_integer_array( current_max_dfas );
  669.     dfasiz = allocate_integer_array( current_max_dfas );
  670.     accsiz = allocate_integer_array( current_max_dfas );
  671.     dhash = allocate_integer_array( current_max_dfas );
  672.     dss = allocate_int_ptr_array( current_max_dfas );
  673.     dfaacc = allocate_dfaacc_union( current_max_dfas );
  674.     }
  675.  
  676.  
  677.